package manage.modules;

import java.util.List;
import java.util.Map;

import org.springframework.jdbc.core.JdbcOperations;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;

/**
 * 基本服务类，后面加上的服务类都组合这个注入吧
 * 
 * @author dongji
 * @since 2012-9-6 下午03:55:26
 */
public interface BaseService {

	/**
	 * 获取NamedParameterJdbc，执行带:abc占位符的sql语句
	 * 
	 * @return
	 */
	NamedParameterJdbcTemplate getNamedJdbc();

	/**
	 * 获取JdbcOperations，执行带?的sql语句
	 * 
	 * @return
	 */
	JdbcOperations getJdbcOperations();

	/**
	 * 添加缓存(如果缓存中存在此cacheKey会抛异常)
	 * 
	 * @param cacheKey
	 *            缓存的Key
	 * @param value
	 *            缓存的value
	 * @param exp
	 *            a 缓存过期时间
	 * @return
	 */
	boolean addCache(final String cacheKey, final Object value, final int exp);

	/**
	 * 添加缓存，默认过期时间为1hour(如果缓存中存在此cacheKey会抛异常)
	 * 
	 * @param cacheKey
	 *            缓存的Key
	 * @param value
	 *            缓存的value
	 * @return
	 */
	boolean addCache(final String cacheKey, final Object value);

	/**
	 * 添加原生对象,因为其他的方法基本上都在加入缓存时被转化为了json字符串，此方法没有
	 * 
	 * @param key
	 * @param value
	 * @param exp
	 * @return
	 */
	boolean addOriginalCache(final String key, final Object value, final int exp);

	/**
	 * 添加缓存
	 * 
	 * @param cacheKey
	 *            缓存的Key
	 * @param value
	 *            缓存的value
	 * @param exp
	 *            缓存过期时间
	 * @return
	 */
	void setCache(final String cacheKey, final Object value, final int exp);

	/**
	 * 添加缓存，默认过期时间为1hour
	 * 
	 * @param cacheKey
	 *            缓存的Key
	 * @param value
	 *            缓存的value
	 * @return
	 */
	void setCache(final String cacheKey, final Object value);

	/**
	 * 添加原生对象,因为其他的方法基本上都在加入缓存时被转化为了json字符串，此方法没有
	 * 
	 * @param cacheKey
	 *            缓存的Key
	 * @param value
	 *            缓存的value
	 * @return
	 */
	void setOriginalCache(final String cacheKey, final Object value);

	/**
	 * 获取某个缓存的值
	 * 
	 * @param cacheKey
	 *            缓存的Key
	 * @return
	 */
	<T> T getOriginalCache(final String cacheKey);

	/**
	 * 获取某个类型缓存的值
	 * 
	 * @param key
	 *            缓存的Key
	 * @param clazz
	 *            缓存的类型
	 * @return
	 */
	<T> T getCache(final String key, Class<T> clazz);

	/**
	 * 去缓存中取对应的List集合
	 * 
	 * @param cacheKey
	 *            缓存的key
	 * @param clazz
	 *            要返回的集合泛型类别
	 * @return 如果不存在则返回null
	 */
	<T> List<T> getListByCache(final String cacheKey, Class<T> clazz);

	/**
	 * 去缓存中取List<Map<String,Object>对象
	 * 
	 * @param cacheKey
	 *            缓存的key
	 * @return 如果不存在则返回null
	 */
	List<Map<String, Object>> getListMapByCache(final String cacheKey);

	/**
	 * 是否存在某个缓存
	 * 
	 * @param cacheKey
	 *            缓存的key
	 * @return 存在返回true,反之为false
	 */
	boolean existsCache(final String cacheKey);

	/**
	 * 清除缓存
	 * 
	 * @param cacheKey
	 *            缓存的key
	 */
	void clearCache(final String cacheKey);

	/**
	 * 查询clazz对应表中满足fields约束的记录(默认100条)
	 * 
	 * @param <T>
	 * @param fields
	 *            where 约束条件
	 * @param clazz
	 * @return
	 */
	<T> List<T> listByFields(Map<String, Object> fields, Class<T> clazz);

	/**
	 * 查询rowSize条clazz对应表中满足fields约束的记录
	 * 
	 * @param <T>
	 * @param fields
	 *            where 约束条件
	 * @param clazz
	 * @param rowIndex
	 * @param rowSize
	 * @return
	 */
	<T> List<T> listByFields(Map<String, Object> fields, Class<T> clazz,
			int rowIndex, int rowSize);

	/**
	 * 查询clazz对应表中满足field=value约束的记录(默认100条)
	 * 
	 * @param <T>
	 * @param field
	 * @param value
	 * @param clazz
	 * @return
	 */
	<T> List<T> listByField(String field, Object value, Class<T> clazz);

	/**
	 * 查询rowSiz条clazz对应表中满足field=value约束的记录
	 * 
	 * @param <T>
	 * @param field
	 * @param value
	 * @param clazz
	 * @param rowIndex
	 * @param rowSize
	 * @return
	 */
	<T> List<T> listByField(String field, Object value, Class<T> clazz,
			int rowIndex, int rowSize);

	/**
	 * 查询clazz对应表中满足field like %value%的数据(默认100条)
	 * 
	 * @param <T>
	 * @param field
	 * @param value
	 * @param clazz
	 * @return
	 */
	<T> List<T> listByFieldLike(String field, Object value, Class<T> clazz);

	/**
	 * 查询rowSiz条clazz对应表中满足field like %value%的数据
	 * 
	 * @param <T>
	 * @param field
	 * @param value
	 * @param clazz
	 * @param rowIndex
	 * @param rowSize
	 * @return
	 */
	<T> List<T> listByFieldLike(String field, Object value, Class<T> clazz,
			int rowIndex, int rowSize);

	/**
	 * 随机查询clazz对应表中rowSize条field=value的数据
	 * 
	 * @param <T>
	 * @param field
	 * @param value
	 * @param clazz
	 * @param rowSize
	 * @return
	 */
	<T> List<T> listByFieldRandom(String field, Object value, Class<T> clazz,
			int rowSize);

	/**
	 * 查询全表
	 * 
	 * @param <T>
	 * @param clazz
	 *            对应的类
	 * @return
	 */
	<T> List<T> listAll(Class<T> clazz);

	/**
	 * 查询符合fidld=value对应的记录
	 * 
	 * @param <T>
	 * @param field
	 *            键名
	 * @param value
	 *            键值
	 * @param clazz
	 *            对应的类
	 * @return
	 */
	<T> T select(String field, Object value, Class<T> clazz);

	/**
	 * 查询符合fields键值对对应的记录
	 * 
	 * @param <T>
	 * @param conditions
	 *            约束条件
	 * @param clazz
	 *            对应的类
	 * @return
	 */
	<T> T select(Map<String, Object> conditions, Class<T> clazz);

	/**
	 * 插入一条记录返回影响的行数
	 * 
	 * @param <T>
	 * @param entity
	 *            要写入的实体
	 * @return 影响的行数
	 */
	<T> int insert(T entity);

	/**
	 * 插入一条记录返回生成的ID
	 * 
	 * @param <T>
	 * @param entity
	 *            要写入的实体
	 * @return 生成的ID
	 */
	<T> long insertFetchId(T entity);

	/**
	 * 替换对应的对象语句
	 * 
	 * @param <T>
	 * @param entity
	 * @return
	 */
	<T> int replace(T entity);

	/**
	 * 更新field=value对应的记录
	 * 
	 * @param <T>
	 * @param field
	 *            键名
	 * @param value
	 *            键值
	 * @param clazz
	 *            对应的类
	 * @return
	 */
	<T> int updateFields(String field, Object value, T entity);

	/**
	 * 更新符合fields键值对对应的记录(conditions不会更新)
	 * 
	 * @param <T>
	 * @param fields
	 *            要更新的字段
	 * @param conditions
	 *            conditions更新约束条件
	 * @param clazz
	 * @return
	 */
	<T> int updateFields(Map<String, Object> fields,
			Map<String, Object> conditions, Class<T> clazz);

	/**
	 * 删除field=value对应的记录
	 * 
	 * @param <T>
	 * @param field
	 *            键名
	 * @param value
	 *            键值
	 * @param clazz
	 *            对应的类
	 * @return
	 */
	<T> int delete(String field, Object value, Class<T> clazz);

	/**
	 * 删除符合fields键值对的记录(2^31-1条)
	 * 
	 * @param <T>
	 * @param fields
	 * @param clazz
	 * @return
	 */
	<T> int deleteByFields(Map<String, Object> fields, Class<T> clazz);

	/**
	 * 删除rowSize条符合fields键值对的记录
	 * 
	 * @param <T>
	 * @param fields
	 * @param clazz
	 * @param rowSize
	 * @return
	 */
	<T> int deleteByFields(Map<String, Object> fields, Class<T> clazz,
			int rowSize);

	/**
	 * 检field=value对应的记录是否存在
	 * 
	 * @param <T>
	 * @param field
	 *            键名
	 * @param value
	 *            键值
	 * @param clazz
	 *            对应的类
	 * @return 存在返回true,反之返回false
	 */
	<T> boolean exists(String field, Object value, Class<T> clazz);

	/**
	 * 检查满足fields对应的记录是否存在
	 * 
	 * @param <T>
	 * @param fields
	 *            约束键值对
	 * @param clazz
	 *            对应的类
	 * @return 存在返回true,反之返回false
	 */
	<T> boolean exists(Map<String, Object> fields, Class<T> clazz);

	/**
	 * 得到对应的全表的count语句
	 * 
	 * @param <T>
	 * @param clazz
	 * @return
	 */
	<T> Long countOfAll(Class<T> clazz);

	/**
	 * 得到符合field=value的count（1）值
	 * 
	 * @param <T>
	 * @param field
	 * @param value
	 * @param clazz
	 * @return
	 */
	<T> Long countByField(String field, String value, Class<T> clazz);

	/**
	 * 得到符合fields键值对的count（1）值
	 * 
	 * @param <T>
	 * @param fields
	 * @param clazz
	 * @return
	 */
	<T> Long countByFields(Map<String, Object> fields, Class<T> clazz);

	/**
	 * 根据传入sql返回对应的count(1)语句
	 * 
	 * @param sql
	 * @return
	 */
	String getCountSql(String sql);

	/**
	 * 比较dest对象与src对象有哪些值不同
	 * 
	 * @param <T>
	 * @param src
	 * @param dest
	 * @return
	 */
	<T> Map<String, Object> comparePojo(T src, T dest);

}
